internal abstract class Command<TParameters, TResult>(TParameters @params, string method) : Command(method, typeof(TResult))
    where TParameters : Parameters
    where TResult : EmptyResult
{
    [JsonPropertyOrder(2)]
    public TParameters Params { get; } = @params;
}

internal record Parameters
{
    public static Parameters Empty { get; } = new Parameters();
}

public async Task<TResult> ExecuteCommandAsync<TCommand, TResult>(TCommand command, Options? options)
    where TCommand : Command
    where TResult : EmptyResult
{
    var result = await ExecuteCommandCoreAsync(command, options).ConfigureAwait(false);

    return (TResult)result;
}

private async Task<EmptyResult> ExecuteCommandCoreAsync<TCommand>(TCommand command, Options? options)

public async Task<NavigateResult> NavigateAsync(BrowsingContext context, string url, NavigateOptions? options = null)
{
    var @params = new NavigateParameters(context, url, options?.Wait);

    return await Broker.ExecuteCommandAsync<NavigateCommand, NavigateResult>(new NavigateCommand(@params), options).ConfigureAwait(false);
}

public async Task<EmptyResult> ActivateAsync(BrowsingContext context, ActivateOptions? options = null)
{
    var @params = new ActivateParameters(context);

    return await Broker.ExecuteCommandAsync<ActivateCommand, EmptyResult>(new ActivateCommand(@params), options).ConfigureAwait(false);
}

public async Task<LocateNodesResult> LocateNodesAsync(BrowsingContext context, Locator locator, LocateNodesOptions? options = null)
{
    var @params = new LocateNodesParameters(context, locator, options?.MaxNodeCount, options?.SerializationOptions, options?.StartNodes);

    return await Broker.ExecuteCommandAsync<LocateNodesCommand, LocateNodesResult>(new LocateNodesCommand(@params), options).ConfigureAwait(false);
}

public async Task<CaptureScreenshotResult> CaptureScreenshotAsync(BrowsingContext context, CaptureScreenshotOptions? options = null)
{
    var @params = new CaptureScreenshotParameters(context, options?.Origin, options?.Format, options?.Clip);

    return await Broker.ExecuteCommandAsync<CaptureScreenshotCommand, CaptureScreenshotResult>(new CaptureScreenshotCommand(@params), options).ConfigureAwait(false);
}

public async Task<EmptyResult> CloseAsync(BrowsingContext context, CloseOptions? options = null)
{
    var @params = new CloseParameters(context, options?.PromptUnload);

    return await Broker.ExecuteCommandAsync<CloseCommand, EmptyResult>(new CloseCommand(@params), options).ConfigureAwait(false);
}

public async Task<TraverseHistoryResult> TraverseHistoryAsync(BrowsingContext context, int delta, TraverseHistoryOptions? options = null)
{
    var @params = new TraverseHistoryParameters(context, delta);

    return await Broker.ExecuteCommandAsync<TraverseHistoryCommand, TraverseHistoryResult>(new TraverseHistoryCommand(@params), options).ConfigureAwait(false);
}

public async Task<NavigateResult> ReloadAsync(BrowsingContext context, ReloadOptions? options = null)
{
    var @params = new ReloadParameters(context, options?.IgnoreCache, options?.Wait);

    return await Broker.ExecuteCommandAsync<ReloadCommand, NavigateResult>(new ReloadCommand(@params), options).ConfigureAwait(false);
}

public async Task<EmptyResult> SetViewportAsync(BrowsingContext context, SetViewportOptions? options = null)
{
    var @params = new SetViewportParameters(context, options?.Viewport, options?.DevicePixelRatio);

    return await Broker.ExecuteCommandAsync<SetViewportCommand, EmptyResult>(new SetViewportCommand(@params), options).ConfigureAwait(false);
}

public async Task<GetTreeResult> GetTreeAsync(GetTreeOptions? options = null)
{
    var @params = new GetTreeParameters(options?.MaxDepth, options?.Root);

    return await Broker.ExecuteCommandAsync<GetTreeCommand, GetTreeResult>(new GetTreeCommand(@params), options).ConfigureAwait(false);
}

public async Task<PrintResult> PrintAsync(BrowsingContext context, PrintOptions? options = null)
{
    var @params = new PrintParameters(context, options?.Background, options?.Margin, options?.Orientation, options?.Page, options?.PageRanges, options?.Scale, options?.ShrinkToFit);

    return await Broker.ExecuteCommandAsync<PrintCommand, PrintResult>(new PrintCommand(@params), options).ConfigureAwait(false);
}

public async Task<EmptyResult> HandleUserPromptAsync(BrowsingContext context, HandleUserPromptOptions? options = null)
{
    var @params = new HandleUserPromptParameters(context, options?.Accept, options?.UserText);

    return await Broker.ExecuteCommandAsync<HandleUserPromptCommand, EmptyResult>(new HandleUserPromptCommand(@params), options).ConfigureAwait(false);

// Public API base class
public abstract class CommandOptions { ... }

// Public options class for consumers
public sealed class CloseOptions : CommandOptions;

// Method signature in public API
public async Task<TResult> ExecuteCommandAsync<TCommand, TResult>(TCommand command, CommandOptions? options)

// Public API base class is renamed, a breaking change
public abstract class Options { ... }

// Public options class now has a different base type
public sealed class CloseOptions : Options;

// Method signature in public API is changed
public async Task<TResult> ExecuteCommandAsync<TCommand, TResult>(TCommand command, Options? options)